package com.deliinsns.sys;
import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class BasicDao<T> extends HibernateDaoSupport {
	
	  protected Class<T> clasz;
	/* 查询模块*/
	@SuppressWarnings("unchecked")
	public List<T> findByHql(String hql){	//根据hql语句查询结果，无替换参数
		return getHibernateTemplate().find(hql);
	}
	@SuppressWarnings("unchecked")
	public List<T> findByHql(String hql,Object value){	//根据hql语句查询结果，有一个替换参数
		return getHibernateTemplate().find(hql,value);
	}
	@SuppressWarnings("unchecked")
	public List<T> findByHql(String hql,Object[] values){	//根据hql语句查询结果，数组values为替换参数
		return getHibernateTemplate().find(hql,values);
	}
	
	@SuppressWarnings("unchecked")
	public T get(Class entityClass,Serializable id){	//根据持久化标示符得到对应的实体对象 ，（立即加载）
		return (T)getHibernateTemplate().get(entityClass, id);
	}
	@SuppressWarnings("unchecked")
	public T load(Class entityClass,Serializable id){	//根据持久化标示符得到对应的实体对象 ，（延迟加载）
		return (T)getHibernateTemplate().load(entityClass, id);
	}
	@SuppressWarnings("unchecked")
	public List<T> loadAll(Class entityClass){	//根据实体类名得到所有的实体对象 
		return getHibernateTemplate().loadAll(entityClass);
	}
	
	@SuppressWarnings("unchecked")
	public List<T> findByCriteria(DetachedCriteria crit,int first,int maxResult) {	//根据查询条件对象查询结果,带分页
    	return getHibernateTemplate().findByCriteria(crit, first, maxResult);
	}
	
	@SuppressWarnings("unchecked")
	public List<T> findByCriteria(DetachedCriteria crit) {	//根据查询条件对象查询结果
    	return getHibernateTemplate().findByCriteria(crit);
	}
	@SuppressWarnings("unchecked")
	public Integer getCount(final DetachedCriteria detachedCriteria) {
        return (Integer) getHibernateTemplate().execute(new HibernateCallback() {
            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = detachedCriteria.getExecutableCriteria(session);
                int totalCount = (Integer) criteria.setProjection(
                        Projections.rowCount()).uniqueResult();
                criteria.setProjection(null);
                criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
                return totalCount;
            }
        });
	}
	
	
	/* 删除模块*/
	public void delete(String entityName, Integer id) {
		 T entity= (T)getHibernateTemplate().get(entityName, id);
		 getHibernateTemplate().delete(entity);
	}
	public void delete(T entity) {
		getHibernateTemplate().delete(entity);
	}
	public void delete(List<T> entities) {
		getHibernateTemplate().deleteAll(entities);
	}
	
	public void flush(T entity) {
		getHibernateTemplate().flush();
	}
	
	/* 持久模块*/
	public void save(T entity) {	//持久化对象至数据库
			getHibernateTemplate().save(entity);
	}

	public void saveOrUpdate(T entity) {	//持久化对象至数据库，如果该对象已经存在，则更新该记录
			getHibernateTemplate().saveOrUpdate(entity);
	}
	public void update(T entity) {	//更新对象至数据库
			getHibernateTemplate().update(entity);
	}
	public void merge(T entity) {	//更新(合并)对象至数据库
			getHibernateTemplate().merge(entity);
	}
	public void persist(T entity) {	//持久化对象至数据库，该动作不一定会立即执行，可能会延迟执行
											//在transaction外部调用就不会执行
			getHibernateTemplate().persist(entity);
	}


}
